Summary T5.txt

This week we discuss a paper dealing with "Speculative Decoupled Software Pipelining". It bases on last week's paper, but due to the fact that DSWP is not mighty enough to parallelize many loops it expands this approach by using speculation. The problem that arises when certain loops are parallelized is that there are dependence recurrences inhibiting a parallelization using DSWP. To solve this problem thread-level speculation could be used to break special dependences speculatively, but this would also enlarge the latency on the critical path because of the necessary communication. SpecDSWP can avoid this enlargement by keeping the organization pipelined. In cases of misspeculation the approach provides a mechanism to recover the program state. For this purpose threads create a kind of snapshot before executing a new iteration. When misspeculation is detected every thread restores its changes to memory and the registers and continues executing the iteration sequentially. In order to find the edges in the dependence graph the algorithm speculates all highly predictable dependences provisionally. Then threads are allocated to the remaining edges in the PDG using a partitioning heuristic. After that it identifies all provisionally speculated edges that crosses the thread border and at the same time points from a later thread to an earlier one in the pipeline. The edges that are found this way are exactly the edges that need to be speculated. A likely use-case for SpecDSWP are biased branches. This means that one branch of a condition is taken in most cases and the other branch only rarely. In such a case the compiler can break the control dependence. Technically this speculation is implemented as an unconditional branch replacing the conditional one. To detect misspeculation a boolean flag is set when the unlikely branch is taken and the rollback-mechanism re-executes this branch sequentially.